import axios from 'axios'

// 创建axios实例
const api = axios.create({
  baseURL: 'http://localhost:5090/api',
  timeout: 5000,
  headers: {
    'Content-Type': 'application/json',
  }
})

// 请求拦截器
api.interceptors.request.use(
  config => {
    // 添加用户认证信息
    const user = JSON.parse(localStorage.getItem('user') || 'null')
    if (user && user.userId) {
      config.headers['X-User-Id'] = user.userId
      config.headers['X-User-Name'] = user.username
    }
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    return response.data
  },
  error => {
    console.error('API请求错误:', error)
    return Promise.reject(error)
  }
)

// 用户相关API
export const userAPI = {
  // 用户注册
  register(userData) {
    return api.post('/user/register', userData)
  },
  
  // 用户登录
  login(credentials) {
    return api.post('/user/login', credentials)
  },
  
  // 获取用户信息
  getUserInfo(userId) {
    return api.get(`/user/${userId}`)
  },
  
  // 更新用户信息
  updateUser(userId, userData) {
    return api.put(`/user/update/${userId}`, userData)
  },
  
  // 创建用户（管理员功能）
  createUser(userData) {
    return api.post('/user/create', userData)
  },
  
  // 删除用户（管理员功能）
  deleteUser(userId) {
    return api.delete(`/user/${userId}`)
  },
  
  // 获取所有用户（管理员功能）
  getAllUsers() {
    return api.get('/user/all')
  },
  
  // 更新用户状态（管理员功能）
  updateUserStatus(userId, status) {
    return api.put('/user/status', { userId, status })
  },
  
  // 批量更新用户状态
  batchUpdateUserStatus(userIds, status) {
    return api.put('/user/batch/status', { userIds, status })
  },
  
  // 批量删除用户
  batchDeleteUsers(userIds) {
    return api.delete('/user/batch', { data: { userIds } })
  }
}

// 管理员相关API
export const adminAPI = {
  // 管理员登录
  login(credentials) {
    return api.post('/admin/login', credentials)
  },
  
  // 创建管理员
  createAdmin(adminData) {
    return api.post('/admin/create', adminData)
  }
}

// 商品相关API
export const productAPI = {
  // 获取所有商品
  getAllProducts() {
    return api.get('/product/all')
  },
  
  // 分页获取商品
  getProductsByPage(page = 0, size = 10) {
    return api.get(`/product/page?page=${page}&size=${size}`)
  },
  
  // 根据ID获取商品详情
  getProductById(productId) {
    return api.get(`/product/${productId}`)
  },
  
  // 根据分类获取商品
  getProductsByCategory(categoryId) {
    return api.get(`/product/category/${categoryId}`)
  },
  
  // 搜索商品
  searchProducts(keyword) {
    return api.get(`/product/search?keyword=${keyword}`)
  },
  
  // 获取热门商品
  getHotProducts() {
    return api.get('/product/hot')
  },
  
  // 添加商品（管理员功能）
  addProduct(productData) {
    return api.post('/product/add', productData)
  },
  
  // 更新商品（管理员功能）
  updateProduct(productId, productData) {
    return api.put(`/product/update/${productId}`, productData)
  },
  
  // 删除商品（管理员功能）
  deleteProduct(productId) {
    return api.delete(`/product/${productId}`)
  },
  
  // 批量删除商品（管理员功能）
  deleteProducts(productIds) {
    return api.delete('/product/batch', { data: productIds })
  }
}

// 分类相关API
export const categoryAPI = {
  // 获取所有分类
  getAllCategories() {
    return api.get('/category/all')
  },
  
  // 获取顶级分类
  getTopLevelCategories() {
    return api.get('/category/top')
  },
  
  // 根据父分类获取子分类
  getCategoriesByParent(parentId) {
    return api.get(`/category/children/${parentId}`)
  },
  
  // 根据ID获取分类
  getCategoryById(categoryId) {
    return api.get(`/category/${categoryId}`)
  },
  
  // 添加分类（管理员功能）
  addCategory(categoryData) {
    return api.post('/category/add', categoryData)
  },
  
  // 更新分类（管理员功能）
  updateCategory(categoryId, categoryData) {
    return api.put(`/category/update/${categoryId}`, categoryData)
  },
  
  // 删除分类（管理员功能）
  deleteCategory(categoryId) {
    return api.delete(`/category/${categoryId}`)
  },
  
  // 批量删除分类（管理员功能）
  deleteCategories(categoryIds) {
    return api.delete('/category/batch', { data: categoryIds })
  }
}

// 订单相关API
export const orderAPI = {
  // 创建订单
  createOrder(orderData) {
    return api.post('/order/create', orderData)
  },
  
  // 根据用户ID获取订单
  getOrdersByUserId(userId) {
    return api.get(`/order/user/${userId}`)
  },
  
  // 获取当前用户订单
  getUserOrders(userId) {
    // 如果没有传入userId，从localStorage获取当前用户
    if (!userId) {
      const user = JSON.parse(localStorage.getItem('user') || 'null')
      if (user && user.userId) {
        userId = user.userId
      } else {
        return Promise.reject(new Error('用户未登录'))
      }
    }
    return api.get(`/order/user/${userId}`)
  },
  
  // 根据订单ID获取订单详情
  getOrderById(orderId) {
    return api.get(`/order/${orderId}`)
  },
  
  // 获取所有订单（管理员功能）
  getAllOrders() {
    return api.get('/order/all')
  },
  
  // 根据状态获取订单（管理员功能）
  getOrdersByStatus(status) {
    return api.get(`/order/status/${status}`)
  },
  
  // 更新订单状态
  updateOrderStatus(orderId, status) {
    return api.put('/order/status', { orderId, status })
  },
  
  // 更新订单信息（管理员功能）
  updateOrder(orderId, orderData) {
    return api.put(`/order/update/${orderId}`, orderData)
  },
  
  // 删除订单（管理员功能）
  deleteOrder(orderId) {
    return api.delete(`/order/${orderId}`)
  },
  
  // 获取订单详情
  getOrderDetails(orderId) {
    return api.get(`/order/details/${orderId}`)
  },
  
  // 批量更新订单状态（管理员功能）
  batchUpdateOrderStatus(orderIds, status) {
    return api.put('/order/batch/status', { orderIds, status })
  },
  
  // 批量删除订单（管理员功能）
  batchDeleteOrders(orderIds) {
    return api.delete('/order/batch', { data: orderIds })
  }
}

// 地址相关API
export const addressAPI = {
  // 获取用户地址列表
  getUserAddresses(userId) {
    return api.get(`/address/user/${userId}`)
  },
  
  // 添加地址
  addAddress(addressData) {
    return api.post('/address/add', addressData)
  },
  
  // 更新地址
  updateAddress(addressData) {
    return api.put('/address/update', addressData)
  },
  
  // 删除地址
  deleteAddress(addressId) {
    return api.delete(`/address/${addressId}`)
  },
  
  // 设置默认地址
  setDefaultAddress(addressId) {
    return api.put('/address/default', { addressId })
  }
}

export default api 